/**
 * 构造页面pageJson的children
 */
const forMatVueChildren= (result) => {
  let resultJson = [
		{
			id: "XPage",
			name:"XPage",
			slot: null,
			props:{
				class:""
			},
			children:[],
			bindData:{},
			condition:null,
			auth:false,
			on:{}
		}
	];
	
	/**
	 * children为当前解析的子集
	 * arr 为承载格式化的结构
	 */
	const fn = (children, arr) => {
		children.forEach(v=> {
			let model = {};
			// 表示当前是文本节点或者解析字符串
			if([2, 3].includes(v.type) && v.text.trim()){
				model = {
					id: dynamicUuid('XLabel'),
					name: 'XLabel',
					// 暂定所有节点未有插槽功能
					slot: null,
					// 暂定将所有节点属性和方法认定为props
					props: {
						tag: "span",
						class: ""
					},
					children: [],
					// 动态绑定属性暂时合并到了props中未进行区分，后续会进行拆分
					bindData: {
						text: '`' + `${convertCurlyBracesToTemplate(v.text)}` + '`',
					},
					// 权限也是自己设置 寄存在v-permission方法
					condition: null,
					auth: false,
					// 由于将事件都自己吃掉了，所以不能依赖于低代码的事件抛出方式 $event 和 $scope
					on: {}
				}
				arr.push(model)
			}
			if(v.type == 1){
				// 需要区分静态属性和动态属性
				let props = {};
				let bindDataProps = {};

				v.attrsMap && Object.keys(v.attrsMap).forEach(j=> {
					if(j.includes(":")){
						bindDataProps[j.substring(1)] = v.attrsMap[j]
					} else {
						props[j] = v.attrsMap[j]
					}
				})

				// 表示当前是组件节点
				model = {
					id: dynamicUuid(v.tag),
					name: getComponentName(v.tag),
					// 暂定所有节点未有插槽功能
					slot: null,
					// 暂定将所有节点属性和方法认定为props
					props,
					children: [],
					// 动态绑定属性暂时合并到了props中未进行区分，后续会进行拆分
					bindData: bindDataProps,
					// 权限也是自己设置 寄存在v-permission方法
					condition: null,
					auth: false,
					// 由于将事件都自己吃掉了，所以不能依赖于低代码的事件抛出方式 $event 和 $scope
					on: {}
				}
				// 此处是查询子级的节点
				if(v.children && v.children.length){
					fn(v.children, model.children)
				}

				// 此处是查询当前节点的插槽的节点
				let slots = Object.keys(v.scopedSlots || {});
				if(slots.length){
					slots.forEach(j=> {

						// 此处需要构建插槽节点的结构到children里面
						let slotModel = {
							id: dynamicUuid('XSlot'),
							name: getComponentName(v.scopedSlots[j].tag || 'template'),
							// 暂定所有节点未有插槽功能
							slot: null,
							// 这里直接继承插槽上的所有属性和方法赋予props
							props: computedSlotProps(v.scopedSlots[j].attrsMap),
							children: [],
							// 动态绑定属性暂时合并到了props中未进行区分，后续会进行拆分
							bindData: {},
							// 权限也是自己设置 寄存在v-permission方法
							condition: null,
							auth: false,
							// 由于将事件都自己吃掉了，所以不能依赖于低代码的事件抛出方式 $event 和 $scope
							on: {}
						}
						fn(v.scopedSlots[j].children || [], slotModel.children)
						model.children.push(slotModel)
					})
					
				}
				arr.push(model)
			}
			
		})
	}

	fn(result.ast.children, resultJson[0].children)
  return resultJson
}

/**
 * 解决当前文本节点格式化问题
 * 将 {{ ... }} 语法转换为 ${ ... } 语法
 * @param {string} str - 输入的字符串
 * @returns {string} - 转换后的字符串
 */
function convertCurlyBracesToTemplate(str) {
	// 正则解释：
	// \{\s*      : 匹配 { 后面跟随零个或多个空白字符
	// (         : 开始捕获组
	// (?:'([^']*)'|"([^"]*)"|([^}]*))
	//   (?:'([^']*)'|"([^"]*)") : 非捕获组，匹配单引号或双引号包围的内容
	//   |                     : 或者
	//   ([^}]*)              : 匹配不包含 } 的任何字符（用于表达式）
	// )
	// \s*\} : 匹配零个或多个空白字符后跟 }
	const regex = /\{\{\s*(?:'([^']*)'|"([^"]*)"|([^}]*))\s*\}\}/g;
	let result = str;

	// 使用正则的 replace 方法进行替换
	result = result.replace(regex, (match, p1, p2, p3) => {
			// 如果有单引号或双引号包裹的内容，保留引号
			if (p1 !== undefined) {
					return `\${'${p1}'}`;
			} else if (p2 !== undefined) {
					return `\${"${p2}"}`;
			} else if (p3 !== undefined) {
					// 如果没有引号包裹，则直接包裹为 ${...}
					return `\${${p3}}`;
			} else {
					// 如果没有匹配到任何内容，返回原样
					return match;
			}
	});

	return result;
}

/**
 * 生成插槽的属性
 * 由于当插槽组件是这类格式时 会不生成属性 <template #custom></template>
 * 通过低代码的转换会生成 <template></template> 因为当前属性值为空，所以需要生成一个随机变量
 * 不能用固定变量的原因是防止上下文变量冲突
 */
const computedSlotProps = (props) => {
	let computedSlots = {}
	if(!props) return computedSlots;

	Object.keys(props).forEach(v=> {
		if(!props[v]){
			computedSlots[v] = dynamicUuid('slot')
		}else{
			computedSlots[v] = props[v]
		}
	})

	return computedSlots
}